package com.hedl.practice.diyJava.reflex.method_access;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;

public class Method {
    /**
     * Class类提供了以下几个方法来获取Method：
     *          Method getMethod(name, Class...)：获取某个public的Method（包括父类）    ,getMethod(方法名，参数类型)
     *          Method getDeclaredMethod(name, Class...)：获取当前类的某个Method（不包括父类）
     *          Method[] getMethods()：获取所有public的Method（包括父类）
     *          Method[] getDeclaredMethods()：获取当前类的所有Method（不包括父类）
     *
     * 一个Method对象包含一个方法的所有信息：
     *          getName()：返回方法名称，例如："getScore"；
     *          getReturnType()：返回方法返回值类型，也是一个Class实例，例如：String.class；
     *          getParameterTypes()：返回方法的参数类型，是一个Class数组，例如：{String.class, int.class}；
     *          getModifiers()：返回方法的修饰符，它是一个int，不同的bit表示不同的含义。
     */

    public static void main(String[] args) {

        /*Class cls = Student.class;
        try {
            //获取public方法getScore，参数为String:
            System.out.println("获取public方法getScore，参数为String ---->"+cls.getMethod("getScore", String.class));
            //获取继承的public方法getName，无参数:
            System.out.println("获取继承的public方法getName，无参数 ---->" +cls.getMethod( "getName"));
            //// 获取private方法getGrade，参数为int:
            System.out.println("获取private方法getGrade，参数为int ---->"+cls.getDeclaredMethod("getGrade", int.class));

        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }*/

        //方法调用
        /*String s = "Hello world";

        try {
            //获取String substring(int)方法，参数为int:
            java.lang.reflect.Method m = String.class.getMethod("substring", int.class);
            //// 在s对象上调用该方法并获取结果:
            String r = (String) m.invoke(s,6);
            System.out.println(r);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }*/

        //调用静态方法
        /*try {
            //获取Integer.parseInt(String)方法，参数为String:
            java.lang.reflect.Method m = Integer.class.getMethod("parseInt", String.class);
            //调用该静态方法并获取结果:
            Integer i = (Integer) m.invoke(null,"12345");
            System.out.println(i);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }*/

        //调用非public方法
        Person p = new Person();
        try {
            java.lang.reflect.Method m = p.getClass().getDeclaredMethod("setName", String.class);
            m.setAccessible(true);
            m.invoke(p,"Xiao Ming");
            System.out.println(p.getName());

        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }

    }
}

class Student extends Person{
    public int getScore(String type){
        return 99;
    }
    private int getGrade(int year){
        return 1;
    }
}

class Person{
    private String name;
    private void setName(String name){
        this.name = name;
    }

    public String getName(){
        return "Person:"+name;
    }
}